/**
 * 应用状态管理对象
 * 存储所有运行时状态和用户设置
 */
const state = {
    // 运行状态
    isRunning: false,           // 自动运行状态
    currentIndex: 0,            // 当前处理的索引

    // 筛选条件
    includeKeywords: [],        // 包含关键词列表
    locationKeywords: [],       // 位置关键词列表

    // 数据缓存
    jobList: [],                // 职位列表缓存

    // UI 状态
    ui: {
        isMinimized: false,                     // 面板最小化状态
        theme: localStorage.getItem('theme') || 'light', // 主题设置
        showWelcomeMessage: JSON.parse(localStorage.getItem('showWelcomeMessage') || 'true') // 是否显示欢迎信息
    },

    // HR交互状态
    hrInteractions: {
        processedHRs: new Set(JSON.parse(localStorage.getItem('processedHRs') || '[]')), // 已处理HR集合
        currentTopHRKey: null,                                                         // 当前顶级HR标识
        sentGreetingsHRs: new Set(JSON.parse(localStorage.getItem('sentGreetingsHRs') || '[]')), // 已发送问候HR集合
        sentResumeHRs: new Set(JSON.parse(localStorage.getItem('sentResumeHRs') || '[]')),       // 已发送简历HR集合
        sentImageResumeHRs: new Set(JSON.parse(localStorage.getItem('sentImageResumeHRs') || '[]')) // 已发送图片简历HR集合
    },

    // AI 功能
    ai: {
        replyCount: JSON.parse(localStorage.getItem('aiReplyCount') || '0'), // AI回复计数
        lastAiDate: localStorage.getItem('lastAiDate') || '',              // 最后使用AI回复的日期
        useAiReply: true                                                   // 是否启用AI回复
    },

    // 操作记录
    operation: {
        lastMessageTime: 0,                                // 最后发送消息时间
        processedJobsCount: 0,                             // 已处理职位数量
        lastProcessedDate: localStorage.getItem('lastProcessedDate') || '', // 最后处理日期
        dailyJobLimit: 50                                  // 每日处理职位上限
    },

    // 用户权限
    user: {
        isPremiumUser: localStorage.getItem('isPremiumUser') === 'true' // 是否为高级用户
    },

    // 应用设置
    settings: {
        useAutoSendResume: JSON.parse(localStorage.getItem('useAutoSendResume') || 'true'), // 是否自动发送简历
        useAutoSendImageResume: JSON.parse(localStorage.getItem('useAutoSendImageResume') || 'false'), // 是否自动发送图片简历
        imageResumes: JSON.parse(localStorage.getItem('imageResumes') || '[]'), // 图片简历列表
        autoScrollSpeed: parseInt(localStorage.getItem('autoScrollSpeed') || '500'), // 自动滚动速度
        customPhrases: JSON.parse(localStorage.getItem('customPhrases') || '[]'), // 自定义常用语
        actionDelays: {
            click: parseInt(localStorage.getItem('clickDelay') || '130') // 点击延迟
        },
        notifications: {
            enabled: JSON.parse(localStorage.getItem('notificationsEnabled') || 'true'), // 是否启用通知
            sound: JSON.parse(localStorage.getItem('notificationSound') || 'true') // 是否启用通知声音
        }
    }
};

/**
 * DOM元素引用对象
 * 存储所有需要频繁访问的DOM元素
 */
const elements = {
    panel: null,           // 主面板元素
    controlBtn: null,      // 控制按钮
    log: null,             // 日志显示区域
    includeInput: null,    // 包含关键词输入框
    locationInput: null,   // 位置关键词输入框
    miniIcon: null,        // 最小化图标
    aiRoleInput: null,     // AI角色设置输入框
    themeToggle: null,     // 主题切换开关
    settingsPanel: null    // 设置面板
};

/**
 * 存储管理工具类
 * 负责统一的localStorage操作封装和存储限制管理
 */
class StorageManager {
    /**
     * 统一的localStorage操作封装
     * @param {string} key - 存储键名
     * @param {any} value - 要存储的值
     * @returns {boolean} 是否成功
     */
    static setItem(key, value) {
        try {
            localStorage.setItem(key, typeof value === 'string' ? value : JSON.stringify(value));
            return true;
        } catch (error) {
            Core.log(`设置存储项 ${key} 失败: ${error.message}`);
            return false;
        }
    }

    /**
     * 统一的localStorage读取操作封装
     * @param {string} key - 存储键名
     * @param {any} defaultValue - 默认值
     * @returns {any} 存储的值或默认值
     */
    static getItem(key, defaultValue = null) {
        try {
            const value = localStorage.getItem(key);
            return value !== null ? value : defaultValue;
        } catch (error) {
            Core.log(`获取存储项 ${key} 失败: ${error.message}`);
            return defaultValue;
        }
    }

    /**
     * 向本地存储添加记录，自动处理数量限制
     * @param {string} storageKey - 存储键名
     * @param {string} record - 要添加的记录
     * @param {Set} currentSet - 当前的Set对象引用
     * @param {number} limit - 最大记录数量限制
     */
    static addRecordWithLimit(storageKey, record, currentSet, limit) {
        try {
            // 如果记录已存在，直接返回
            if (currentSet.has(record)) {
                return;
            }

            // 获取并验证现有记录
            let records = this.getParsedItem(storageKey, []);
            records = Array.isArray(records) ? records : [];

            // 如果达到或超过限制，删除最早的记录（FIFO原则）
            if (records.length >= limit) {
                records.shift();
            }

            // 添加新记录并保存到本地存储
            records.push(record);
            currentSet.add(record);
            this.setItem(storageKey, records);

            // 记录操作日志
            console.log(`存储管理: 添加记录${records.length >= limit ? '并删除最早记录' : ''}，当前${storageKey}数量: ${records.length}/${limit}`);
        } catch (error) {
            console.log(`存储管理出错: ${error.message}`);
        }
    }

    /**
     * 从本地存储获取解析后的记录
     * @param {string} storageKey - 存储键名
     * @param {any} defaultValue - 默认值
     * @returns {any} 解析后的记录
     */
    static getParsedItem(storageKey, defaultValue = []) {
        try {
            const data = this.getItem(storageKey);
            return data ? JSON.parse(data) : defaultValue;
        } catch (error) {
            Core.log(`解析存储记录出错: ${error.message}`);
            return defaultValue;
        }
    }

    /**
     * 为HR交互记录批量设置数量限制管理
     * 确保所有HR交互记录都在存储限制范围内
     */
    static ensureStorageLimits() {
        const limitConfigs = [
            { key: CONFIG.STORAGE_KEYS.PROCESSED_HRS, set: state.hrInteractions.processedHRs, limit: CONFIG.STORAGE_LIMITS.PROCESSED_HRS },
            { key: CONFIG.STORAGE_KEYS.SENT_GREETINGS_HRS, set: state.hrInteractions.sentGreetingsHRs, limit: CONFIG.STORAGE_LIMITS.SENT_GREETINGS_HRS },
            { key: CONFIG.STORAGE_KEYS.SENT_RESUME_HRS, set: state.hrInteractions.sentResumeHRs, limit: CONFIG.STORAGE_LIMITS.SENT_RESUME_HRS },
            { key: CONFIG.STORAGE_KEYS.SENT_IMAGE_RESUME_HRS, set: state.hrInteractions.sentImageResumeHRs, limit: CONFIG.STORAGE_LIMITS.SENT_IMAGE_RESUME_HRS }
        ];

        limitConfigs.forEach(({ key, set, limit }) => {
            const records = this.getParsedItem(key, []);
            if (records.length > limit) {
                // 只保留最新的记录
                const trimmedRecords = records.slice(-limit);
                this.setItem(key, trimmedRecords);

                // 更新内存中的Set
                set.clear();
                trimmedRecords.forEach(record => set.add(record));

                console.log(`存储管理: 清理${key}记录，从${records.length}减少到${trimmedRecords.length}`);
            }
        });
    }
}

/**
 * 状态持久化管理类
 * 负责应用状态的保存和加载
 */
class StatePersistence {
    /**
     * 保存当前应用状态到本地存储
     * 批量保存多个状态配置
     */
    static saveState() {
        try {
            // 定义状态映射，减少重复代码
            const stateMap = {
                'aiReplyCount': state.ai.replyCount,
                'lastAiDate': state.ai.lastAiDate,
                'lastProcessedDate': state.operation.lastProcessedDate,
                'showWelcomeMessage': state.ui.showWelcomeMessage,
                'isPremiumUser': state.user.isPremiumUser,
                'useAiReply': state.ai.useAiReply,
                'useAutoSendResume': state.settings.useAutoSendResume,
                'useAutoSendImageResume': state.settings.useAutoSendImageResume,
                'imageResumeData': state.settings.imageResumeData,
                'imageResumes': state.settings.imageResumes || [],
                'autoScrollSpeed': state.settings.autoScrollSpeed,
                'customPhrases': state.settings.customPhrases,
                'theme': state.ui.theme,
                'clickDelay': state.settings.actionDelays.click,
                'notificationsEnabled': state.settings.notifications.enabled,
                'notificationSound': state.settings.notifications.sound,
                'includeKeywords': state.includeKeywords,
                'locationKeywords': state.locationKeywords
            };

            // 批量保存状态到本地存储
            Object.entries(stateMap).forEach(([key, value]) => {
                StorageManager.setItem(key, value);
            });
        } catch (error) {
            Core.log(`保存状态失败: ${error.message}`);
        }
    }

    /**
     * 从本地存储加载应用状态
     * 加载筛选条件和图片简历数据，并确保存储限制
     */
    static loadState() {
        try {
            // 加载筛选条件（兼容旧版）
            state.includeKeywords = StorageManager.getParsedItem('includeKeywords', []);
            state.locationKeywords = StorageManager.getParsedItem('locationKeywords') ||
                StorageManager.getParsedItem('excludeKeywords', []);

            // 加载多图片简历数据
            const imageResumes = StorageManager.getParsedItem('imageResumes', []);
            if (Array.isArray(imageResumes)) state.settings.imageResumes = imageResumes;

            // 确保所有HR交互记录都在存储限制范围内
            StorageManager.ensureStorageLimits();
        } catch (error) {
            Core.log(`加载状态失败: ${error.message}`);
        }
    }
}

/**
 * HR交互管理类
 * 负责处理与HR的所有交互逻辑，包括消息发送、简历投递等
 */
class HRInteractionManager {
    /**
     * 从岗位名称中提取双字关键词
     * @param {string} positionName - 岗位名称
     * @returns {Array} 双字关键词数组
     */
    // 使用Core.extractTwoCharKeywords代替

    /**
     * 根据岗位名称选择最合适的图片简历
     * @param {string} positionName - 岗位名称
     * @returns {object|null} 选中的简历对象或null
     */
    // selectImageResume方法已移至下方，此处省略重复实现
    /**
     * 根据HR状态执行相应操作
     * @param {string} hrKey - HR标识（如："姓名-公司名"）
     */
    static async handleHRInteraction(hrKey) {
        // 检查HR是否已发送消息
        const hasResponded = await this.hasHRResponded();

        // 未发过常用语，处理首次交互逻辑
        if (!state.hrInteractions.sentGreetingsHRs.has(hrKey)) {
            await this._handleFirstInteraction(hrKey);
            return;
        }

        // 已发常用语但未发简历，检查是否需要发送简历
        if (!state.hrInteractions.sentResumeHRs.has(hrKey) || !state.hrInteractions.sentImageResumeHRs.has(hrKey)) {
            if (hasResponded) {
                await this._handleFollowUpResponse(hrKey);
            }
            return;
        }

        // 已发简历，使用AI自动回复
        await Core.aiReply();
    }

    /**
     * 处理首次与HR交互的逻辑
     * @param {string} hrKey - HR标识
     */
    static async _handleFirstInteraction(hrKey) {
        Core.log(`首次沟通: ${hrKey}`);
        const sentGreeting = await this.sendGreetings();

        if (sentGreeting) {
            // 记录已发送常用语到本地存储
            StorageManager.addRecordWithLimit(
                CONFIG.STORAGE_KEYS.SENT_GREETINGS_HRS,
                hrKey,
                state.hrInteractions.sentGreetingsHRs,
                CONFIG.STORAGE_LIMITS.SENT_GREETINGS_HRS
            );

            // 处理简历发送逻辑
            await this._handleResumeSending(hrKey);
        }
    }

    /**
     * 处理简历发送逻辑
     * 根据用户设置自动发送普通简历和图片简历
     * @param {string} hrKey - HR标识
     * @returns {Promise<void>}
     */
    static async _handleResumeSending(hrKey) {
        // 发送普通简历
        if (state.settings.useAutoSendResume && !state.hrInteractions.sentResumeHRs.has(hrKey)) {
            const sentResume = await this.sendResume();
            if (sentResume) {
                StorageManager.addRecordWithLimit(
                    CONFIG.STORAGE_KEYS.SENT_RESUME_HRS,
                    hrKey,
                    state.hrInteractions.sentResumeHRs,
                    CONFIG.STORAGE_LIMITS.SENT_RESUME_HRS
                );
            }
        }

        // 发送图片简历
        if (state.settings.useAutoSendImageResume && !state.hrInteractions.sentImageResumeHRs.has(hrKey)) {
            const sentImageResume = await this.sendImageResume();
            if (sentImageResume) {
                StorageManager.addRecordWithLimit(
                    CONFIG.STORAGE_KEYS.SENT_IMAGE_RESUME_HRS,
                    hrKey,
                    state.hrInteractions.sentImageResumeHRs,
                    CONFIG.STORAGE_LIMITS.SENT_IMAGE_RESUME_HRS
                );
            }
        }
    }

    /**
     * 处理HR回复后的逻辑
     * 根据HR的回复内容执行相应的后续操作
     * @param {string} hrKey - HR标识
     * @returns {Promise<void>}
     */
    static async _handleFollowUpResponse(hrKey) {
        const lastMessage = await Core.getLastFriendMessageText();

        if (lastMessage && (lastMessage.includes('简历') || lastMessage.includes('发送简历'))) {
            Core.log(`HR提到"简历"，发送简历: ${hrKey}`);

            // 优先发送图片简历
            if (state.settings.useAutoSendImageResume && !state.hrInteractions.sentImageResumeHRs.has(hrKey)) {
                const sentImageResume = await this.sendImageResume();
                if (sentImageResume) {
                    state.hrInteractions.sentImageResumeHRs.add(hrKey);
                    StatePersistence.saveState();
                    Core.log(`已向 ${hrKey} 发送图片简历`);
                    return;
                }
            }

            // 发送普通简历
            if (!state.hrInteractions.sentResumeHRs.has(hrKey)) {
                const sentResume = await this.sendResume();
                if (sentResume) {
                    state.hrInteractions.sentResumeHRs.add(hrKey);
                    StatePersistence.saveState();
                    Core.log(`已向 ${hrKey} 发送简历`);
                }
            }
        }
    }

    /**
     * 检查HR是否已回复消息
     */
    static async hasHRResponded() {
        await Core.delay(state.settings.actionDelays.click);

        const chatContainer = document.querySelector('.chat-message .im-list');
        if (!chatContainer) return false;

        const friendMessages = Array.from(chatContainer.querySelectorAll('li.message-item.item-friend'));
        return friendMessages.length > 0;
    }

    /**
     * 发送常用语
     */
    static async sendGreetings() {
        try {
            const dictBtn = await Core.waitForElement('.btn-dict');
            if (!dictBtn) {
                Core.log('未找到常用语（自我介绍）按钮');
                return false;
            }
            await Core.simulateClick(dictBtn);
            await Core.smartDelay(state.settings.actionDelays.click, 'click');
            await Core.smartDelay(300, 'dict_load'); // 确保常用语列表加载完成

            const dictList = await Core.waitForElement('ul[data-v-1d93a2d5=""]');
            if (!dictList) {
                Core.log('未找到常用语（自我介绍）');
                return false;
            }

            const dictItems = dictList.querySelectorAll('li');
            if (!dictItems || dictItems.length === 0) {
                Core.log('常用语列表（自我介绍）为空');
                return false;
            }

            for (let i = 0; i < dictItems.length; i++) {
                const item = dictItems[i];
                Core.log(`发送常用语（自我介绍）：第${i + 1}条/共${dictItems.length}条`);
                await Core.simulateClick(item);
                await Core.delay(state.settings.actionDelays.click);
            }

            return true;
        } catch (error) {
            Core.log(`发送常用语出错: ${error.message}`);
            return false;
        }
    }

    /**
     * 发送简历
     */

    /**
     * 根据双字关键词查找匹配的简历
     * @param {Array} resumeItems - 简历项数组
     * @param {string} positionName - 岗位名称
     * @returns {HTMLElement|null} 匹配的简历项或null
     */
    static _findMatchingResume(resumeItems, positionName) {
        try {
            const positionNameLower = positionName.toLowerCase();
            const twoCharKeywords = Core.extractTwoCharKeywords(positionNameLower);

            for (const keyword of twoCharKeywords) {
                for (const item of resumeItems) {
                    const resumeNameElement = item.querySelector('.resume-name');
                    if (!resumeNameElement) continue;

                    const resumeName = resumeNameElement.textContent.trim().toLowerCase();

                    if (resumeName.includes(keyword)) {
                        const resumeNameText = resumeNameElement.textContent.trim();
                        Core.log(`智能匹配简历: "${resumeNameText}" 匹配依据: "${keyword}"`);
                        return item;
                    }
                }
            }

            return null;
        } catch (error) {
            Core.log(`简历匹配出错: ${error.message}`);
            return null;
        }
    }

    static async sendResume() {
        try {
            const resumeBtn = await Core.waitForElement(() => {
                return [...document.querySelectorAll('.toolbar-btn')].find(
                    el => el.textContent.trim() === '发简历'
                );
            });

            if (!resumeBtn) {
                Core.log('无法发送简历，未找到发简历按钮');
                return false;
            }

            if (resumeBtn.classList.contains('unable')) {
                Core.log('对方未回复，您无权发送简历');
                return false;
            }

            // 获取当前岗位名称
            let positionName = '';
            try {
                const positionNameElement = Core.getCachedElement('.position-name', true) ||
                    Core.getCachedElement('.job-name', true) ||
                    Core.getCachedElement('[class*="position-content"] .left-content .position-name', true);

                if (positionNameElement) {
                    positionName = positionNameElement.textContent.trim();
                } else {
                    Core.log('未找到岗位名称元素');
                }
            } catch (e) {
                Core.log(`获取岗位名称出错: ${e.message}`);
            }

            await Core.simulateClick(resumeBtn);
            await Core.smartDelay(state.settings.actionDelays.click, 'click');
            await Core.smartDelay(800, 'resume_load'); // 确保简历列表或确认框加载完成

            // 检查是否出现了确认对话框（用户只有一份附件简历的情况）
            const confirmDialog = document.querySelector('.panel-resume.sentence-popover');
            if (confirmDialog) {
                Core.log('您只有一份附件简历');

                // 直接点击确定按钮
                const confirmBtn = confirmDialog.querySelector('.btn-sure-v2');
                if (!confirmBtn) {
                    Core.log('未找到确认按钮');
                    return false;
                }

                await Core.simulateClick(confirmBtn);
                return true;
            }

            // 多份简历的情况，使用原有的简历选择逻辑
            const resumeList = await Core.waitForElement('ul.resume-list');
            if (!resumeList) {
                Core.log('未找到简历列表');
                return false;
            }

            const resumeItems = Array.from(resumeList.querySelectorAll('li.list-item'));
            if (resumeItems.length === 0) {
                Core.log('未找到简历列表项');
                return false;
            }

            let selectedResumeItem = null;
            if (positionName) {
                selectedResumeItem = this._findMatchingResume(resumeItems, positionName);
            }

            if (!selectedResumeItem) {
                selectedResumeItem = resumeItems[0];
                const resumeName = selectedResumeItem.querySelector('.resume-name').textContent.trim();
                Core.log('使用第一个简历: "' + resumeName + '"');
            }

            await Core.simulateClick(selectedResumeItem);
            await Core.smartDelay(state.settings.actionDelays.click, 'click');
            await Core.smartDelay(500, 'selection'); // 确保选择生效

            const sendBtn = await Core.waitForElement('button.btn-v2.btn-sure-v2.btn-confirm');
            if (!sendBtn) {
                Core.log('未找到发送按钮');
                return false;
            }

            if (sendBtn.disabled) {
                Core.log('发送按钮不可用，可能简历未正确选择');
                return false;
            }

            await Core.simulateClick(sendBtn);
            return true;
        } catch (error) {
            Core.log(`发送简历出错: ${error.message}`);
            return false;
        }
    }

    // 选择匹配的图片简历
    static selectImageResume(positionName) {
        try {
            const positionNameLower = positionName.toLowerCase();

            // 如果只有一个简历，直接返回
            if (state.settings.imageResumes.length === 1) {
                return state.settings.imageResumes[0];
            }

            // 提取双字关键词
            const twoCharKeywords = Core.extractTwoCharKeywords(positionNameLower);

            // 按关键词优先级（从左到右）遍历
            for (const keyword of twoCharKeywords) {
                // 查找包含当前关键词的简历
                for (const resume of state.settings.imageResumes) {
                    const resumeNameLower = resume.path.toLowerCase();

                    // 检查简历名称是否包含当前关键词
                    if (resumeNameLower.includes(keyword)) {
                        Core.log(`智能匹配简历: "${resume.path}" 匹配依据: "${keyword}"`);
                        return resume;
                    }
                }
            }

            // 未找到匹配，返回第一个简历
            return state.settings.imageResumes[0];
        } catch (error) {
            Core.log(`选择图片简历出错: ${error.message}`);
            return state.settings.imageResumes[0] || null;
        }
    }

    /**
     * Send image resume
     */
    static async sendImageResume() {
        try {
            if (!state.settings.useAutoSendImageResume || !state.settings.imageResumes || state.settings.imageResumes.length === 0) {
                return false;
            }

            // 获取当前聊天的岗位名称
            let positionName = '';
            try {
                // 尝试从职位卡片获取岗位名称
                const positionNameElement = Core.getCachedElement('.position-name', true) ||
                    Core.getCachedElement('.job-name', true) ||
                    Core.getCachedElement('[class*="position-content"] .left-content .position-name', true);

                if (positionNameElement) {
                    positionName = positionNameElement.textContent.trim();
                } else {
                    Core.log('未找到岗位名称元素');
                    // 如果无法获取岗位名称，仍然继续发送，使用默认简历
                    positionName = '';
                }
            } catch (e) {
                Core.log(`获取岗位名称出错: ${e.message}`);
                // 出错时仍然继续发送，使用默认简历
                positionName = '';
            }

            // 使用selectImageResume方法选择合适的图片简历
            const selectedResume = this.selectImageResume(positionName);

            // 检查是否有待发送的图片简历数据
            if (!selectedResume || !selectedResume.data) {
                Core.log('没有可发送的图片简历数据');
                return false;
            }

            // 找到图片发送按钮
            const imageSendBtn = await Core.waitForElement('.toolbar-btn-content.icon.btn-sendimg input[type="file"]');
            if (!imageSendBtn) {
                Core.log('未找到图片发送按钮');
                return false;
            }

            // 创建一个Blob对象
            const byteCharacters = atob(selectedResume.data.split(',')[1]);
            const byteNumbers = new Array(byteCharacters.length);
            for (let i = 0; i < byteCharacters.length; i++) {
                byteNumbers[i] = byteCharacters.charCodeAt(i);
            }
            const byteArray = new Uint8Array(byteNumbers);
            const blob = new Blob([byteArray], { type: 'image/jpeg' });

            // 创建一个File对象
            const file = new File([blob], selectedResume.path, {
                type: 'image/jpeg',
                lastModified: new Date().getTime()
            });

            // 创建一个DataTransfer对象来模拟文件选择
            const dataTransfer = new DataTransfer();
            dataTransfer.items.add(file);

            // 设置文件输入的值
            imageSendBtn.files = dataTransfer.files;

            // 触发change事件
            const event = new Event('change', { bubbles: true });
            imageSendBtn.dispatchEvent(event);
            Core.log(`成功发送图片: ${selectedResume.path}`);
            return true;
        } catch (error) {
            Core.log(`发送图片出错: ${error.message}`);
            return false;
        }
    }
};


// 初始化加载状态
StatePersistence.loadState();

// 导出状态和工具类
window.state = state;
window.elements = elements;
window.StatePersistence = StatePersistence;
window.HRInteractionManager = HRInteractionManager;
